//
// CDriverUser.java
// Copyright (C) 2010  "Naush" <naush _ hotmail _ fr>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>./* ----------------------------------------------------------------------------
package org.ryzom.nel.threed;

import org.ryzom.nel.misc.CQuad;
import org.ryzom.nel.misc.CRGBA;

public class CDriverUser {
  private long swigCPtr;
  protected boolean swigCMemOwn;

  public CDriverUser(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }

  public static long getCPtr(CDriverUser obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  protected void finalize() {
    delete();
  }

  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        nel3dJNI.delete_CDriverUser(swigCPtr);
      }
      swigCPtr = 0;
    }
  }

  public CDriverUser(long windowIcon, boolean direct3d, SWIGTYPE_p_f_void__void exitFunc) {
    this(nel3dJNI.new_CDriverUser__SWIG_0(windowIcon, direct3d, SWIGTYPE_p_f_void__void.getCPtr(exitFunc)), true);
  }
/*
  public CDriverUser(long windowIcon, boolean direct3d) {
    this(nel3dJNI.new_CDriverUser__SWIG_1(windowIcon, direct3d), true);
  }
*/
  public CDriverUser(long windowIcon) {
    this(nel3dJNI.new_CDriverUser__SWIG_2(windowIcon), true);
  }

  public CDriverUser() {
    this(nel3dJNI.new_CDriverUser__SWIG_3(), true);
  }

  public boolean isLost() {
    return nel3dJNI.CDriverUser_isLost(swigCPtr, this);
  }

  public void disableHardwareVertexProgram() {
    nel3dJNI.CDriverUser_disableHardwareVertexProgram(swigCPtr, this);
  }

  public void disableHardwareVertexArrayAGP() {
    nel3dJNI.CDriverUser_disableHardwareVertexArrayAGP(swigCPtr, this);
  }

  public void disableHardwareTextureShader() {
    nel3dJNI.CDriverUser_disableHardwareTextureShader(swigCPtr, this);
  }

  public boolean setDisplay(SWIGTYPE_p_CMode mode, boolean show, boolean resizeable) {
    return nel3dJNI.CDriverUser_setDisplay__SWIG_0(swigCPtr, this, SWIGTYPE_p_CMode.getCPtr(mode), show, resizeable);
  }

  public boolean setDisplay(int wnd, SWIGTYPE_p_CMode mode, boolean show, boolean resizeable) {
    return nel3dJNI.CDriverUser_setDisplay__SWIG_1(swigCPtr, this, wnd, SWIGTYPE_p_CMode.getCPtr(mode), show, resizeable);
  }

  public boolean setMode(SWIGTYPE_p_CMode mode) {
    return nel3dJNI.CDriverUser_setMode(swigCPtr, this, SWIGTYPE_p_CMode.getCPtr(mode));
  }

  public boolean getModes(SWIGTYPE_p_std__vectorT_CMode_t modes) {
    return nel3dJNI.CDriverUser_getModes(swigCPtr, this, SWIGTYPE_p_std__vectorT_CMode_t.getCPtr(modes));
  }

  public boolean getCurrentScreenMode(SWIGTYPE_p_CMode mode) {
    return nel3dJNI.CDriverUser_getCurrentScreenMode(swigCPtr, this, SWIGTYPE_p_CMode.getCPtr(mode));
  }

  public void beginDialogMode() {
    nel3dJNI.CDriverUser_beginDialogMode(swigCPtr, this);
  }

  public void endDialogMode() {
    nel3dJNI.CDriverUser_endDialogMode(swigCPtr, this);
  }

  public void setWindowTitle(SWIGTYPE_p_ucstring title) {
    nel3dJNI.CDriverUser_setWindowTitle(swigCPtr, this, SWIGTYPE_p_ucstring.getCPtr(title));
  }

  public void setWindowIcon(SWIGTYPE_p_std__vectorT_NLMISC__CBitmap_t bitmaps) {
    nel3dJNI.CDriverUser_setWindowIcon(swigCPtr, this, SWIGTYPE_p_std__vectorT_NLMISC__CBitmap_t.getCPtr(bitmaps));
  }

  public void setWindowPos(int x, int y) {
    nel3dJNI.CDriverUser_setWindowPos(swigCPtr, this, x, y);
  }

  public void showWindow(boolean show) {
    nel3dJNI.CDriverUser_showWindow(swigCPtr, this, show);
  }

  public void release() {
    nel3dJNI.CDriverUser_release(swigCPtr, this);
  }

  public boolean activate() {
    return nel3dJNI.CDriverUser_activate(swigCPtr, this);
  }

  public boolean isActive() {
    return nel3dJNI.CDriverUser_isActive(swigCPtr, this);
  }

  public int getDisplay() {
    return nel3dJNI.CDriverUser_getDisplay(swigCPtr, this);
  }

  public void clearRGBABuffer(CRGBA col) {
    nel3dJNI.CDriverUser_clearRGBABuffer__SWIG_0(swigCPtr, this, CRGBA.getCPtr(col), col);
  }

  public void clearRGBABuffer() {
    nel3dJNI.CDriverUser_clearRGBABuffer__SWIG_1(swigCPtr, this);
  }

  public void clearZBuffer() {
    nel3dJNI.CDriverUser_clearZBuffer(swigCPtr, this);
  }

  public void clearBuffers(CRGBA col) {
    nel3dJNI.CDriverUser_clearBuffers__SWIG_0(swigCPtr, this, CRGBA.getCPtr(col), col);
  }

  public void clearBuffers() {
    nel3dJNI.CDriverUser_clearBuffers__SWIG_1(swigCPtr, this);
  }

  public void swapBuffers() {
    nel3dJNI.CDriverUser_swapBuffers(swigCPtr, this);
  }

  public void finish() {
    nel3dJNI.CDriverUser_finish(swigCPtr, this);
  }

  public void flush() {
    nel3dJNI.CDriverUser_flush(swigCPtr, this);
  }

  public void setSwapVBLInterval(long interval) {
    nel3dJNI.CDriverUser_setSwapVBLInterval(swigCPtr, this, interval);
  }

  public long getSwapVBLInterval() {
    return nel3dJNI.CDriverUser_getSwapVBLInterval(swigCPtr, this);
  }

  public boolean fogEnabled() {
    return nel3dJNI.CDriverUser_fogEnabled(swigCPtr, this);
  }

  public void enableFog(boolean enable) {
    nel3dJNI.CDriverUser_enableFog(swigCPtr, this, enable);
  }

  public void setupFog(float start, float end, CRGBA color) {
    nel3dJNI.CDriverUser_setupFog(swigCPtr, this, start, end, CRGBA.getCPtr(color), color);
  }

  public void setLight(short num, ULight light) {
    nel3dJNI.CDriverUser_setLight(swigCPtr, this, num, ULight.getCPtr(light), light);
  }

  public void enableLight(short num, boolean enable) {
    nel3dJNI.CDriverUser_enableLight__SWIG_0(swigCPtr, this, num, enable);
  }

  public void enableLight(short num) {
    nel3dJNI.CDriverUser_enableLight__SWIG_1(swigCPtr, this, num);
  }

  public void setAmbientColor(CRGBA color) {
    nel3dJNI.CDriverUser_setAmbientColor(swigCPtr, this, CRGBA.getCPtr(color), color);
  }

  public void setCullMode(SWIGTYPE_p_TCullMode cullMode) {
    nel3dJNI.CDriverUser_setCullMode(swigCPtr, this, SWIGTYPE_p_TCullMode.getCPtr(cullMode));
  }

  public SWIGTYPE_p_TCullMode getCullMode() {
    return new SWIGTYPE_p_TCullMode(nel3dJNI.CDriverUser_getCullMode(swigCPtr, this), true);
  }

  public void enableStencilTest(boolean enable) {
    nel3dJNI.CDriverUser_enableStencilTest(swigCPtr, this, enable);
  }

  public boolean isStencilTestEnabled() {
    return nel3dJNI.CDriverUser_isStencilTestEnabled(swigCPtr, this);
  }

  public void stencilFunc(SWIGTYPE_p_TStencilFunc stencilFunc, int ref, long mask) {
    nel3dJNI.CDriverUser_stencilFunc(swigCPtr, this, SWIGTYPE_p_TStencilFunc.getCPtr(stencilFunc), ref, mask);
  }

  public void stencilOp(SWIGTYPE_p_TStencilOp fail, SWIGTYPE_p_TStencilOp zfail, SWIGTYPE_p_TStencilOp zpass) {
    nel3dJNI.CDriverUser_stencilOp(swigCPtr, this, SWIGTYPE_p_TStencilOp.getCPtr(fail), SWIGTYPE_p_TStencilOp.getCPtr(zfail), SWIGTYPE_p_TStencilOp.getCPtr(zpass));
  }

  public void stencilMask(long mask) {
    nel3dJNI.CDriverUser_stencilMask(swigCPtr, this, mask);
  }

  public UScene createScene(boolean bSmallScene) {
    long cPtr = nel3dJNI.CDriverUser_createScene(swigCPtr, this, bSmallScene);
    return (cPtr == 0) ? null : new UScene(cPtr, false);
  }

  public void deleteScene(UScene scene) {
    nel3dJNI.CDriverUser_deleteScene(swigCPtr, this, UScene.getCPtr(scene), scene);
  }

  public UAnimationSet createAnimationSet(boolean headerOptim) {
    long cPtr = nel3dJNI.CDriverUser_createAnimationSet__SWIG_0(swigCPtr, this, headerOptim);
    return (cPtr == 0) ? null : new UAnimationSet(cPtr, false);
  }

  public UAnimationSet createAnimationSet() {
    long cPtr = nel3dJNI.CDriverUser_createAnimationSet__SWIG_1(swigCPtr, this);
    return (cPtr == 0) ? null : new UAnimationSet(cPtr, false);
  }

  public UAnimationSet createAnimationSet(String animationSetFile) {
    long cPtr = nel3dJNI.CDriverUser_createAnimationSet__SWIG_2(swigCPtr, this, animationSetFile);
    return (cPtr == 0) ? null : new UAnimationSet(cPtr, false);
  }

  public void deleteAnimationSet(UAnimationSet animationSet) {
    nel3dJNI.CDriverUser_deleteAnimationSet(swigCPtr, this, UAnimationSet.getCPtr(animationSet), animationSet);
  }

  public UTextContext createTextContext(String fontFileName, String fontExFileName) {
    long cPtr = nel3dJNI.CDriverUser_createTextContext__SWIG_0(swigCPtr, this, fontFileName, fontExFileName);
    return (cPtr == 0) ? null : new UTextContext(cPtr, false);
  }

  public UTextContext createTextContext(String fontFileName) {
    long cPtr = nel3dJNI.CDriverUser_createTextContext__SWIG_1(swigCPtr, this, fontFileName);
    return (cPtr == 0) ? null : new UTextContext(cPtr, false);
  }

  public void deleteTextContext(UTextContext textContext) {
    nel3dJNI.CDriverUser_deleteTextContext(swigCPtr, this, UTextContext.getCPtr(textContext), textContext);
  }

  public void setFontManagerMaxMemory(long maxMem) {
    nel3dJNI.CDriverUser_setFontManagerMaxMemory(swigCPtr, this, maxMem);
  }

  public String getFontManagerCacheInformation() {
    return nel3dJNI.CDriverUser_getFontManagerCacheInformation(swigCPtr, this);
  }

  public UTextureFile createTextureFile(String file) {
    long cPtr = nel3dJNI.CDriverUser_createTextureFile(swigCPtr, this, file);
    return (cPtr == 0) ? null : new UTextureFile(cPtr, false);
  }

  public void deleteTextureFile(UTextureFile textfile) {
    nel3dJNI.CDriverUser_deleteTextureFile(swigCPtr, this, UTextureFile.getCPtr(textfile), textfile);
  }

  public UTextureMem createTextureMem(long width, long height, SWIGTYPE_p_CBitmap__TType texType) {
    long cPtr = nel3dJNI.CDriverUser_createTextureMem__SWIG_0(swigCPtr, this, width, height, SWIGTYPE_p_CBitmap__TType.getCPtr(texType));
    return (cPtr == 0) ? null : new UTextureMem(cPtr, false);
  }

  public UTextureMem createTextureMem(long width, long height) {
    long cPtr = nel3dJNI.CDriverUser_createTextureMem__SWIG_1(swigCPtr, this, width, height);
    return (cPtr == 0) ? null : new UTextureMem(cPtr, false);
  }

  public void deleteTextureMem(UTextureMem textraw) {
    nel3dJNI.CDriverUser_deleteTextureMem(swigCPtr, this, UTextureMem.getCPtr(textraw), textraw);
  }

  public UMaterial createMaterial() {
    return new UMaterial(nel3dJNI.CDriverUser_createMaterial(swigCPtr, this), true);
  }

  public void deleteMaterial(UMaterial mat) {
    nel3dJNI.CDriverUser_deleteMaterial(swigCPtr, this, UMaterial.getCPtr(mat), mat);
  }

  public void setScissor(CScissor arg0) {
    nel3dJNI.CDriverUser_setScissor(swigCPtr, this, CScissor.getCPtr(arg0), arg0);
  }

  public CScissor getScissor() {
    return new CScissor(nel3dJNI.CDriverUser_getScissor(swigCPtr, this), true);
  }

  public void setViewport(CViewport arg0) {
    nel3dJNI.CDriverUser_setViewport(swigCPtr, this, CViewport.getCPtr(arg0), arg0);
  }

  public CViewport getViewport() {
    return new CViewport(nel3dJNI.CDriverUser_getViewport(swigCPtr, this), true);
  }

  public void setFrustum(CFrustum frust) {
    nel3dJNI.CDriverUser_setFrustum(swigCPtr, this, CFrustum.getCPtr(frust), frust);
  }

  public CFrustum getFrustum() {
    return new CFrustum(nel3dJNI.CDriverUser_getFrustum(swigCPtr, this), true);
  }

  public void setFrustumMatrix(SWIGTYPE_p_NLMISC__CMatrix frust) {
    nel3dJNI.CDriverUser_setFrustumMatrix(swigCPtr, this, SWIGTYPE_p_NLMISC__CMatrix.getCPtr(frust));
  }

  public SWIGTYPE_p_NLMISC__CMatrix getFrustumMatrix() {
    return new SWIGTYPE_p_NLMISC__CMatrix(nel3dJNI.CDriverUser_getFrustumMatrix(swigCPtr, this), true);
  }

  public float getClipSpaceZMin() {
    return nel3dJNI.CDriverUser_getClipSpaceZMin(swigCPtr, this);
  }

  public void setViewMatrix(SWIGTYPE_p_NLMISC__CMatrix mat) {
    nel3dJNI.CDriverUser_setViewMatrix(swigCPtr, this, SWIGTYPE_p_NLMISC__CMatrix.getCPtr(mat));
  }

  public SWIGTYPE_p_NLMISC__CMatrix getViewMatrix() {
    return new SWIGTYPE_p_NLMISC__CMatrix(nel3dJNI.CDriverUser_getViewMatrix(swigCPtr, this), true);
  }

  public void setModelMatrix(SWIGTYPE_p_NLMISC__CMatrix mat) {
    nel3dJNI.CDriverUser_setModelMatrix(swigCPtr, this, SWIGTYPE_p_NLMISC__CMatrix.getCPtr(mat));
  }

  public SWIGTYPE_p_NLMISC__CMatrix getModelMatrix() {
    return new SWIGTYPE_p_NLMISC__CMatrix(nel3dJNI.CDriverUser_getModelMatrix(swigCPtr, this), true);
  }

  public void setMatrixMode2D(CFrustum frust) {
    nel3dJNI.CDriverUser_setMatrixMode2D(swigCPtr, this, CFrustum.getCPtr(frust), frust);
  }

  public void setMatrixMode3D(UCamera camera) {
    nel3dJNI.CDriverUser_setMatrixMode3D(swigCPtr, this, UCamera.getCPtr(camera), camera);
  }

  public void setDepthRange(float znear, float zfar) {
    nel3dJNI.CDriverUser_setDepthRange(swigCPtr, this, znear, zfar);
  }

  public void getDepthRange(SWIGTYPE_p_float znear, SWIGTYPE_p_float zfar) {
    nel3dJNI.CDriverUser_getDepthRange(swigCPtr, this, SWIGTYPE_p_float.getCPtr(znear), SWIGTYPE_p_float.getCPtr(zfar));
  }

  public void setColorMask(boolean bRed, boolean bGreen, boolean bBlue, boolean bAlpha) {
    nel3dJNI.CDriverUser_setColorMask(swigCPtr, this, bRed, bGreen, bBlue, bAlpha);
  }

  public void drawLine(SWIGTYPE_p_NLMISC__CLine tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawLine__SWIG_0(swigCPtr, this, SWIGTYPE_p_NLMISC__CLine.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawLine(SWIGTYPE_p_NLMISC__CLineColor tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawLine__SWIG_1(swigCPtr, this, SWIGTYPE_p_NLMISC__CLineColor.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawLine(SWIGTYPE_p_NLMISC__CLineUV tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawLine__SWIG_2(swigCPtr, this, SWIGTYPE_p_NLMISC__CLineUV.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawLine(SWIGTYPE_p_NLMISC__CLineColorUV tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawLine__SWIG_3(swigCPtr, this, SWIGTYPE_p_NLMISC__CLineColorUV.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawTriangle(CTriangle tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawTriangle__SWIG_0(swigCPtr, this, CTriangle.getCPtr(tri), tri, UMaterial.getCPtr(mat), mat);
  }

  public void drawTriangle(SWIGTYPE_p_NLMISC__CTriangleColor tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawTriangle__SWIG_1(swigCPtr, this, SWIGTYPE_p_NLMISC__CTriangleColor.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawTriangle(SWIGTYPE_p_NLMISC__CTriangleUV tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawTriangle__SWIG_2(swigCPtr, this, SWIGTYPE_p_NLMISC__CTriangleUV.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawTriangle(SWIGTYPE_p_NLMISC__CTriangleColorUV tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawTriangle__SWIG_3(swigCPtr, this, SWIGTYPE_p_NLMISC__CTriangleColorUV.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawQuad(CQuad tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuad__SWIG_0(swigCPtr, this, CQuad.getCPtr(tri), tri, UMaterial.getCPtr(mat), mat);
  }

  public void drawQuad(SWIGTYPE_p_NLMISC__CQuadColor tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuad__SWIG_1(swigCPtr, this, SWIGTYPE_p_NLMISC__CQuadColor.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawQuad(SWIGTYPE_p_NLMISC__CQuadUV tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuad__SWIG_2(swigCPtr, this, SWIGTYPE_p_NLMISC__CQuadUV.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawQuad(SWIGTYPE_p_NLMISC__CQuadColorUV tri, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuad__SWIG_3(swigCPtr, this, SWIGTYPE_p_NLMISC__CQuadColorUV.getCPtr(tri), UMaterial.getCPtr(mat), mat);
  }

  public void drawQuads(SWIGTYPE_p_std__vectorT_NLMISC__CQuadColorUV_t quad, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuads__SWIG_0(swigCPtr, this, SWIGTYPE_p_std__vectorT_NLMISC__CQuadColorUV_t.getCPtr(quad), UMaterial.getCPtr(mat), mat);
  }

  public void drawQuads(SWIGTYPE_p_std__vectorT_NLMISC__CQuadColorUV2_t quad, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuads__SWIG_1(swigCPtr, this, SWIGTYPE_p_std__vectorT_NLMISC__CQuadColorUV2_t.getCPtr(quad), UMaterial.getCPtr(mat), mat);
  }

  public void drawTriangles(SWIGTYPE_p_std__vectorT_NLMISC__CTriangleColorUV_t tris, UMaterial mat) {
    nel3dJNI.CDriverUser_drawTriangles__SWIG_0(swigCPtr, this, SWIGTYPE_p_std__vectorT_NLMISC__CTriangleColorUV_t.getCPtr(tris), UMaterial.getCPtr(mat), mat);
  }

  public void drawQuads(SWIGTYPE_p_NLMISC__CQuadColorUV quads, long nbQuads, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuads__SWIG_2(swigCPtr, this, SWIGTYPE_p_NLMISC__CQuadColorUV.getCPtr(quads), nbQuads, UMaterial.getCPtr(mat), mat);
  }

  public void drawQuads(SWIGTYPE_p_NLMISC__CQuadColorUV2 quads, long nbQuads, UMaterial mat) {
    nel3dJNI.CDriverUser_drawQuads__SWIG_3(swigCPtr, this, SWIGTYPE_p_NLMISC__CQuadColorUV2.getCPtr(quads), nbQuads, UMaterial.getCPtr(mat), mat);
  }

  public void drawTriangles(SWIGTYPE_p_NLMISC__CTriangleColorUV tris, long nbTris, UMaterial mat) {
    nel3dJNI.CDriverUser_drawTriangles__SWIG_1(swigCPtr, this, SWIGTYPE_p_NLMISC__CTriangleColorUV.getCPtr(tris), nbTris, UMaterial.getCPtr(mat), mat);
  }

  public void drawBitmap(float x, float y, float width, float height, UTexture texture, boolean blend, CRGBA col) {
    nel3dJNI.CDriverUser_drawBitmap__SWIG_0(swigCPtr, this, x, y, width, height, UTexture.getCPtr(texture), texture, blend, CRGBA.getCPtr(col), col);
  }

  public void drawBitmap(float x, float y, float width, float height, UTexture texture, boolean blend) {
    nel3dJNI.CDriverUser_drawBitmap__SWIG_1(swigCPtr, this, x, y, width, height, UTexture.getCPtr(texture), texture, blend);
  }

  public void drawBitmap(float x, float y, float width, float height, UTexture texture) {
    nel3dJNI.CDriverUser_drawBitmap__SWIG_2(swigCPtr, this, x, y, width, height, UTexture.getCPtr(texture), texture);
  }

  public void drawLine(float x0, float y0, float x1, float y1, CRGBA col) {
    nel3dJNI.CDriverUser_drawLine__SWIG_4(swigCPtr, this, x0, y0, x1, y1, CRGBA.getCPtr(col), col);
  }

  public void drawLine(float x0, float y0, float x1, float y1) {
    nel3dJNI.CDriverUser_drawLine__SWIG_5(swigCPtr, this, x0, y0, x1, y1);
  }

  public void drawTriangle(float x0, float y0, float x1, float y1, float x2, float y2, CRGBA col) {
    nel3dJNI.CDriverUser_drawTriangle__SWIG_4(swigCPtr, this, x0, y0, x1, y1, x2, y2, CRGBA.getCPtr(col), col);
  }

  public void drawQuad(float x0, float y0, float x1, float y1, CRGBA col) {
    nel3dJNI.CDriverUser_drawQuad__SWIG_4(swigCPtr, this, x0, y0, x1, y1, CRGBA.getCPtr(col), col);
  }

  public void drawQuad(float xcenter, float ycenter, float radius, CRGBA col) {
    nel3dJNI.CDriverUser_drawQuad__SWIG_5(swigCPtr, this, xcenter, ycenter, radius, CRGBA.getCPtr(col), col);
  }

  public void drawWiredQuad(float x0, float y0, float x1, float y1, CRGBA col) {
    nel3dJNI.CDriverUser_drawWiredQuad__SWIG_0(swigCPtr, this, x0, y0, x1, y1, CRGBA.getCPtr(col), col);
  }

  public void drawWiredQuad(float xcenter, float ycenter, float radius, CRGBA col) {
    nel3dJNI.CDriverUser_drawWiredQuad__SWIG_1(swigCPtr, this, xcenter, ycenter, radius, CRGBA.getCPtr(col), col);
  }

  public long getImplementationVersion() {
    return nel3dJNI.CDriverUser_getImplementationVersion(swigCPtr, this);
  }

  public String getDriverInformation() {
    return nel3dJNI.CDriverUser_getDriverInformation(swigCPtr, this);
  }

  public String getVideocardInformation() {
    return nel3dJNI.CDriverUser_getVideocardInformation(swigCPtr, this);
  }

  public long getNbTextureStages() {
    return nel3dJNI.CDriverUser_getNbTextureStages(swigCPtr, this);
  }

  public void getWindowSize(SWIGTYPE_p_unsigned_int width, SWIGTYPE_p_unsigned_int height) {
    nel3dJNI.CDriverUser_getWindowSize(swigCPtr, this, SWIGTYPE_p_unsigned_int.getCPtr(width), SWIGTYPE_p_unsigned_int.getCPtr(height));
  }

  public long getWindowWidth() {
    return nel3dJNI.CDriverUser_getWindowWidth(swigCPtr, this);
  }

  public long getWindowHeight() {
    return nel3dJNI.CDriverUser_getWindowHeight(swigCPtr, this);
  }

  public void getWindowPos(SWIGTYPE_p_int x, SWIGTYPE_p_int y) {
    nel3dJNI.CDriverUser_getWindowPos(swigCPtr, this, SWIGTYPE_p_int.getCPtr(x), SWIGTYPE_p_int.getCPtr(y));
  }

  public long getAvailableVertexAGPMemory() {
    return nel3dJNI.CDriverUser_getAvailableVertexAGPMemory(swigCPtr, this);
  }

  public long getAvailableVertexVRAMMemory() {
    return nel3dJNI.CDriverUser_getAvailableVertexVRAMMemory(swigCPtr, this);
  }

  public void getBuffer(SWIGTYPE_p_CBitmap bitmap) {
    nel3dJNI.CDriverUser_getBuffer(swigCPtr, this, SWIGTYPE_p_CBitmap.getCPtr(bitmap));
  }

  public void getZBuffer(SWIGTYPE_p_std__vectorT_float_t zbuffer) {
    nel3dJNI.CDriverUser_getZBuffer(swigCPtr, this, SWIGTYPE_p_std__vectorT_float_t.getCPtr(zbuffer));
  }

  public void getBufferPart(SWIGTYPE_p_CBitmap bitmap, SWIGTYPE_p_NLMISC__CRect rect) {
    nel3dJNI.CDriverUser_getBufferPart(swigCPtr, this, SWIGTYPE_p_CBitmap.getCPtr(bitmap), SWIGTYPE_p_NLMISC__CRect.getCPtr(rect));
  }

  public void getZBufferPart(SWIGTYPE_p_std__vectorT_float_t zbuffer, SWIGTYPE_p_NLMISC__CRect rect) {
    nel3dJNI.CDriverUser_getZBufferPart(swigCPtr, this, SWIGTYPE_p_std__vectorT_float_t.getCPtr(zbuffer), SWIGTYPE_p_NLMISC__CRect.getCPtr(rect));
  }

  public boolean fillBuffer(SWIGTYPE_p_CBitmap bitmap) {
    return nel3dJNI.CDriverUser_fillBuffer(swigCPtr, this, SWIGTYPE_p_CBitmap.getCPtr(bitmap));
  }

  public SWIGTYPE_p_NLMISC__IMouseDevice enableLowLevelMouse(boolean enable, boolean exclusive) {
    long cPtr = nel3dJNI.CDriverUser_enableLowLevelMouse(swigCPtr, this, enable, exclusive);
    return (cPtr == 0) ? null : new SWIGTYPE_p_NLMISC__IMouseDevice(cPtr, false);
  }

  public SWIGTYPE_p_NLMISC__IKeyboardDevice enableLowLevelKeyboard(boolean enable) {
    long cPtr = nel3dJNI.CDriverUser_enableLowLevelKeyboard(swigCPtr, this, enable);
    return (cPtr == 0) ? null : new SWIGTYPE_p_NLMISC__IKeyboardDevice(cPtr, false);
  }

  public SWIGTYPE_p_NLMISC__IInputDeviceManager getLowLevelInputDeviceManager() {
    long cPtr = nel3dJNI.CDriverUser_getLowLevelInputDeviceManager(swigCPtr, this);
    return (cPtr == 0) ? null : new SWIGTYPE_p_NLMISC__IInputDeviceManager(cPtr, false);
  }

  public void emulateMouseRawMode(boolean enable) {
    nel3dJNI.CDriverUser_emulateMouseRawMode(swigCPtr, this, enable);
  }

  public long getDoubleClickDelay(boolean hardwareMouse) {
    return nel3dJNI.CDriverUser_getDoubleClickDelay(swigCPtr, this, hardwareMouse);
  }

  public void showCursor(boolean b) {
    nel3dJNI.CDriverUser_showCursor(swigCPtr, this, b);
  }

  public void setMousePos(float x, float y) {
    nel3dJNI.CDriverUser_setMousePos(swigCPtr, this, x, y);
  }

  public void setCapture(boolean b) {
    nel3dJNI.CDriverUser_setCapture(swigCPtr, this, b);
  }

  public boolean isSystemCursorCaptured() {
    return nel3dJNI.CDriverUser_isSystemCursorCaptured(swigCPtr, this);
  }

  public void addCursor(String name, SWIGTYPE_p_NLMISC__CBitmap bitmap) {
    nel3dJNI.CDriverUser_addCursor(swigCPtr, this, name, SWIGTYPE_p_NLMISC__CBitmap.getCPtr(bitmap));
  }

  public void setCursor(String name, CRGBA col, short rot, int hotSpotX, int hotSpotY, boolean forceRebuild) {
    nel3dJNI.CDriverUser_setCursor__SWIG_0(swigCPtr, this, name, CRGBA.getCPtr(col), col, rot, hotSpotX, hotSpotY, forceRebuild);
  }

  public void setCursor(String name, CRGBA col, short rot, int hotSpotX, int hotSpotY) {
    nel3dJNI.CDriverUser_setCursor__SWIG_1(swigCPtr, this, name, CRGBA.getCPtr(col), col, rot, hotSpotX, hotSpotY);
  }

  public void setCursorScale(float scale) {
    nel3dJNI.CDriverUser_setCursorScale(swigCPtr, this, scale);
  }

  public SWIGTYPE_p_TMessageBoxId systemMessageBox(String message, String title, SWIGTYPE_p_TMessageBoxType type, SWIGTYPE_p_TMessageBoxIcon icon) {
    return new SWIGTYPE_p_TMessageBoxId(nel3dJNI.CDriverUser_systemMessageBox__SWIG_0(swigCPtr, this, message, title, SWIGTYPE_p_TMessageBoxType.getCPtr(type), SWIGTYPE_p_TMessageBoxIcon.getCPtr(icon)), true);
  }

  public SWIGTYPE_p_TMessageBoxId systemMessageBox(String message, String title, SWIGTYPE_p_TMessageBoxType type) {
    return new SWIGTYPE_p_TMessageBoxId(nel3dJNI.CDriverUser_systemMessageBox__SWIG_1(swigCPtr, this, message, title, SWIGTYPE_p_TMessageBoxType.getCPtr(type)), true);
  }

  public SWIGTYPE_p_TMessageBoxId systemMessageBox(String message, String title) {
    return new SWIGTYPE_p_TMessageBoxId(nel3dJNI.CDriverUser_systemMessageBox__SWIG_2(swigCPtr, this, message, title), true);
  }

  public void setPolygonMode(SWIGTYPE_p_TPolygonMode mode) {
    nel3dJNI.CDriverUser_setPolygonMode(swigCPtr, this, SWIGTYPE_p_TPolygonMode.getCPtr(mode));
  }

  public U3dMouseListener create3dMouseListener() {
    long cPtr = nel3dJNI.CDriverUser_create3dMouseListener(swigCPtr, this);
    return (cPtr == 0) ? null : new U3dMouseListener(cPtr, false);
  }

  public void delete3dMouseListener(U3dMouseListener listener) {
    nel3dJNI.CDriverUser_delete3dMouseListener(swigCPtr, this, U3dMouseListener.getCPtr(listener), listener);
  }

  public SWIGTYPE_p_TPolygonMode getPolygonMode() {
    return new SWIGTYPE_p_TPolygonMode(nel3dJNI.CDriverUser_getPolygonMode(swigCPtr, this), true);
  }

  public void forceDXTCCompression(boolean dxtcComp) {
    nel3dJNI.CDriverUser_forceDXTCCompression(swigCPtr, this, dxtcComp);
  }

  public void forceTextureResize(long divisor) {
    nel3dJNI.CDriverUser_forceTextureResize(swigCPtr, this, divisor);
  }

  public void forceNativeFragmentPrograms(boolean nativeOnly) {
    nel3dJNI.CDriverUser_forceNativeFragmentPrograms(swigCPtr, this, nativeOnly);
  }

  public boolean setMonitorColorProperties(CMonitorColorProperties properties) {
    return nel3dJNI.CDriverUser_setMonitorColorProperties(swigCPtr, this, CMonitorColorProperties.getCPtr(properties), properties);
  }

  public UShapeBank getShapeBank() {
    long cPtr = nel3dJNI.CDriverUser_getShapeBank(swigCPtr, this);
    return (cPtr == 0) ? null : new UShapeBank(cPtr, false);
  }

  public void profileRenderedPrimitives(CPrimitiveProfile pIn, CPrimitiveProfile pOut) {
    nel3dJNI.CDriverUser_profileRenderedPrimitives(swigCPtr, this, CPrimitiveProfile.getCPtr(pIn), pIn, CPrimitiveProfile.getCPtr(pOut), pOut);
  }

  public long profileAllocatedTextureMemory() {
    return nel3dJNI.CDriverUser_profileAllocatedTextureMemory(swigCPtr, this);
  }

  public long profileSetupedMaterials() {
    return nel3dJNI.CDriverUser_profileSetupedMaterials(swigCPtr, this);
  }

  public long profileSetupedModelMatrix() {
    return nel3dJNI.CDriverUser_profileSetupedModelMatrix(swigCPtr, this);
  }

  public void enableUsedTextureMemorySum(boolean enable) {
    nel3dJNI.CDriverUser_enableUsedTextureMemorySum(swigCPtr, this, enable);
  }

  public long getUsedTextureMemory() {
    return nel3dJNI.CDriverUser_getUsedTextureMemory(swigCPtr, this);
  }

  public void startProfileVBHardLock() {
    nel3dJNI.CDriverUser_startProfileVBHardLock(swigCPtr, this);
  }

  public void endProfileVBHardLock(Vector_String result) {
    nel3dJNI.CDriverUser_endProfileVBHardLock(swigCPtr, this, Vector_String.getCPtr(result), result);
  }

  public void profileVBHardAllocation(Vector_String result) {
    nel3dJNI.CDriverUser_profileVBHardAllocation(swigCPtr, this, Vector_String.getCPtr(result), result);
  }

  public void startProfileIBLock() {
    nel3dJNI.CDriverUser_startProfileIBLock(swigCPtr, this);
  }

  public void endProfileIBLock(Vector_String result) {
    nel3dJNI.CDriverUser_endProfileIBLock(swigCPtr, this, Vector_String.getCPtr(result), result);
  }

  public void profileIBAllocation(Vector_String result) {
    nel3dJNI.CDriverUser_profileIBAllocation(swigCPtr, this, Vector_String.getCPtr(result), result);
  }

  public void profileTextureUsage(Vector_String result) {
    nel3dJNI.CDriverUser_profileTextureUsage(swigCPtr, this, Vector_String.getCPtr(result), result);
  }

  public void setupAsyncTextureLod(long baseLevel, long maxLevel) {
    nel3dJNI.CDriverUser_setupAsyncTextureLod(swigCPtr, this, baseLevel, maxLevel);
  }

  public void setupAsyncTextureMaxUploadPerFrame(long maxup) {
    nel3dJNI.CDriverUser_setupAsyncTextureMaxUploadPerFrame(swigCPtr, this, maxup);
  }

  public void setupMaxTotalAsyncTextureSize(long maxText) {
    nel3dJNI.CDriverUser_setupMaxTotalAsyncTextureSize(swigCPtr, this, maxText);
  }

  public void setupMaxHLSColoringPerFrame(long maxCol) {
    nel3dJNI.CDriverUser_setupMaxHLSColoringPerFrame(swigCPtr, this, maxCol);
  }

  public void updateAsyncTexture() {
    nel3dJNI.CDriverUser_updateAsyncTexture(swigCPtr, this);
  }

  public long getTotalAsyncTextureSizeAsked() {
    return nel3dJNI.CDriverUser_getTotalAsyncTextureSizeAsked(swigCPtr, this);
  }

  public long getLastAsyncTextureSizeGot() {
    return nel3dJNI.CDriverUser_getLastAsyncTextureSizeGot(swigCPtr, this);
  }

  public void loadHLSBank(String fileName) {
    nel3dJNI.CDriverUser_loadHLSBank(swigCPtr, this, fileName);
  }

  public boolean supportMADOperator() {
    return nel3dJNI.CDriverUser_supportMADOperator(swigCPtr, this);
  }

  public boolean supportBloomEffect() {
    return nel3dJNI.CDriverUser_supportBloomEffect(swigCPtr, this);
  }

  public void startBench(boolean wantStandardDeviation, boolean quick, boolean reset) {
    nel3dJNI.CDriverUser_startBench__SWIG_0(swigCPtr, this, wantStandardDeviation, quick, reset);
  }

  public void startBench(boolean wantStandardDeviation, boolean quick) {
    nel3dJNI.CDriverUser_startBench__SWIG_1(swigCPtr, this, wantStandardDeviation, quick);
  }

  public void startBench(boolean wantStandardDeviation) {
    nel3dJNI.CDriverUser_startBench__SWIG_2(swigCPtr, this, wantStandardDeviation);
  }

  public void startBench() {
    nel3dJNI.CDriverUser_startBench__SWIG_3(swigCPtr, this);
  }

  public void endBench() {
    nel3dJNI.CDriverUser_endBench(swigCPtr, this);
  }

  public void displayBench(SWIGTYPE_p_NLMISC__CLog log) {
    nel3dJNI.CDriverUser_displayBench(swigCPtr, this, SWIGTYPE_p_NLMISC__CLog.getCPtr(log));
  }

  public UWaterEnvMap createWaterEnvMap() {
    long cPtr = nel3dJNI.CDriverUser_createWaterEnvMap(swigCPtr, this);
    return (cPtr == 0) ? null : new UWaterEnvMap(cPtr, false);
  }

  public void deleteWaterEnvMap(UWaterEnvMap map) {
    nel3dJNI.CDriverUser_deleteWaterEnvMap(swigCPtr, this, UWaterEnvMap.getCPtr(map), map);
  }

  public boolean copyTextToClipboard(SWIGTYPE_p_ucstring text) {
    return nel3dJNI.CDriverUser_copyTextToClipboard(swigCPtr, this, SWIGTYPE_p_ucstring.getCPtr(text));
  }

  public boolean pasteTextFromClipboard(SWIGTYPE_p_ucstring text) {
    return nel3dJNI.CDriverUser_pasteTextFromClipboard(swigCPtr, this, SWIGTYPE_p_ucstring.getCPtr(text));
  }

  public java.math.BigInteger getSwapBufferCounter() {
    return nel3dJNI.CDriverUser_getSwapBufferCounter(swigCPtr, this);
  }

  public boolean stretchRect(UScene scene, UTexture srcUText, SWIGTYPE_p_NLMISC__CRect srcRect, UTexture destUText, SWIGTYPE_p_NLMISC__CRect destRect) {
    return nel3dJNI.CDriverUser_stretchRect(swigCPtr, this, UScene.getCPtr(scene), scene, UTexture.getCPtr(srcUText), srcUText, SWIGTYPE_p_NLMISC__CRect.getCPtr(srcRect), UTexture.getCPtr(destUText), destUText, SWIGTYPE_p_NLMISC__CRect.getCPtr(destRect));
  }

  public boolean setRenderTarget(UTexture uTex, long x, long y, long width, long height, long mipmapLevel, long cubeFace) {
    return nel3dJNI.CDriverUser_setRenderTarget__SWIG_0(swigCPtr, this, UTexture.getCPtr(uTex), uTex, x, y, width, height, mipmapLevel, cubeFace);
  }

  public boolean setRenderTarget(UTexture uTex, long x, long y, long width, long height, long mipmapLevel) {
    return nel3dJNI.CDriverUser_setRenderTarget__SWIG_1(swigCPtr, this, UTexture.getCPtr(uTex), uTex, x, y, width, height, mipmapLevel);
  }

  public boolean setRenderTarget(UTexture uTex, long x, long y, long width, long height) {
    return nel3dJNI.CDriverUser_setRenderTarget__SWIG_2(swigCPtr, this, UTexture.getCPtr(uTex), uTex, x, y, width, height);
  }

  public boolean setRenderTarget(UTexture uTex, long x, long y, long width) {
    return nel3dJNI.CDriverUser_setRenderTarget__SWIG_3(swigCPtr, this, UTexture.getCPtr(uTex), uTex, x, y, width);
  }

  public boolean setRenderTarget(UTexture uTex, long x, long y) {
    return nel3dJNI.CDriverUser_setRenderTarget__SWIG_4(swigCPtr, this, UTexture.getCPtr(uTex), uTex, x, y);
  }

  public boolean setRenderTarget(UTexture uTex, long x) {
    return nel3dJNI.CDriverUser_setRenderTarget__SWIG_5(swigCPtr, this, UTexture.getCPtr(uTex), uTex, x);
  }

  public boolean setRenderTarget(UTexture uTex) {
    return nel3dJNI.CDriverUser_setRenderTarget__SWIG_6(swigCPtr, this, UTexture.getCPtr(uTex), uTex);
  }

  public IDriver getDriver() {
    long cPtr = nel3dJNI.CDriverUser_getDriver(swigCPtr, this);
    return (cPtr == 0) ? null : new IDriver(cPtr, false);
  }

  public void restoreMatrixContext() {
    nel3dJNI.CDriverUser_restoreMatrixContext(swigCPtr, this);
  }

  public void restoreMatrixContextMatrixOnly() {
    nel3dJNI.CDriverUser_restoreMatrixContextMatrixOnly(swigCPtr, this);
  }

}
